Regular research papers:

• Torben Mogensen. Partial Evaluation of the Reversible Language Janus
  
  Abstract: A reversible programming language is a programming language in which you can only write reversible programs, i.e., programs that can be run both forwards (computing outputs from inputs) and backwards (computing inputs from outputs). It is interesting to study reversible programs and languages because computations on reversible computers (computers that only allow reversible programs) in theory can be done using less energy than computations on traditional irreversible computers. Janus is a reversible, structured imperative programming language. The partial evaluator for Janus presented in this paper is believed to be the first partial evaluator for a reversible programming language. The requirement that residual programs must be reversible adds some complications, which we address in the paper.

• Yuta Ikeda and Susumu Nishimura. Calculating Tree Navigation with Symmetric Relational Zipper
  
  Abstract: Navigating through tree structures is a core operation in tree processing programs. Most notably, XML processing programs intensively use XPath, the path specification language that locates particular nodes in a given document structure. In functional programming languages, such tree navigation operations can be implemented by means of Huet's zipper, without using destructive updates on the tree structure. The expected natural symmetry, e.g., the symmetry between the operation for going one-level down in the tree structure and that for coming back the other way around, is not a perfect inverse, because those operations cannot be modeled neatly by functional programs due to partiality and non-injectivity.This paper develops a theory for reasoning about equalities of tree navigation operations. We model basic tree navigation operations, which have a perfect symmetry, by relations over zippers. The relational specification allows us to derive equations by simple calculations. We apply the calculational method to derivation of certain equalities of XPath expressions. The point-free relational reasoning not only leads to a concise justification of some known results derived from the symmetry but also establishes equations for a larger class of tree navigation, including those with negative constraints and those beyond XPath expressibility.

• Enrique Martin-Martin. Type Classes in Functional Logic Programming
  
  Abstract: Type classes provide a clean, modular and elegant way of writing overloaded functions. Functional logic programming languages(FLP in short) like Toy or Curry have adopted the Damas-Milner type system, so it seems natural to adopt also type classes in FLP.However, type classes has been barely introduced in FLP. A reason for this lack of success is that the usual translation of type classes using dictionaries presents some problems in FLP like the absence of expected answers due to a bad interaction of dictionaries with the call-time choice semantics for non-determinism adopted in FLP systems.In this paper we present a type-passing translation of type classes based on type-indexed functions and type witnesses that is well-typed with respect to a new liberal type system recently proposed for FLP. We argue the suitability of this translation for FLP because it improves the dictionary-based one in in three aspects. First, it obtains programs which run as fast or faster---with a speedup from 1.05 to 2.30 in our experiments. Second, it solves the mentioned problem of missing answers. Finally, the proposed translation generates shorter and simpler programs.

• Tim Bauer, Martin Erwig, Alan Fern and Jervis Pinto. Adaptation-Based Programming in Java
  
  Abstract: Writing deterministic programs is often difficult for problems whose optimal solutions depend on unpredictable properties of the programs' inputs.Difficulty is also encountered for problems where the programmer is uncertain about how to best implement certain aspects of a solution. For such problems a mixed strategy of deterministic programming and machine learning can often be very helpful: Initially, define those parts of the program that are well understood and leave the other parts loosely defined through default actions,but also define how those actions can be improved depending on results from actual program runs. Then run the program repeatedly and let the loosely defined parts adapt.In this paper we present a library for Java that facilitates this style of programming, called adaptation-based programming. We motivate the design of the library, define the semantics of adaptation-based programming,and demonstrate through two evaluations that the approach works well in practice.Adaptation-based programming is a form of program generation in which the creation of programs is controlled by previous runs. It facilitates a whole new spectrum of programs between the two extremes of totally deterministic programs and machine learning.

• Hugo Pacheco and Alcino Cunha. Calculating with Lenses: Optimising Bidirectional Transformations
  
  Abstract: This paper presents an equational calculus to reason about bidirectional transformations specified in the point-free style. In particular, it focuses on the so-called lenses as a bidirectional idiom,and shows that many standard laws characterising point-free combinators and recursion patterns are also valid on that setting. A key result is that uniqueness also holds for bidirectional folds and unfolds, thus unleashing the power of fusion as a program optimisation technique. A rewriting system for automatic lens optimisation is also presented, thus proving the usefulness of the proposed calculus.

• Rinus Plasmeijer, Peter Achten, Pieter Koopman, Bas Lijnse, Thomas van Noort and John van Groningen. iTasks for a Change - Type-safe run-time change in dynamically evolving workflows
  
  Abstract: Workflow management systems (WFMS) are software systems that coordinate the tasks human workers and computers have to perform to achieve a certain goal based on a given workflow description. Due to changing circumstances, it happens often that some tasks in a running workflow need to be performed differently than originally planned and specified. Most commercial WFMSs cannot deal with the required run-time changes properly. These changes have to be specified at the level of the underlying Petri-Net based semantics. Moreover, the implicit external state has to be adapted to the new task as well. Such low-level updates can easily lead to wrong behaviour and other errors. This problem is known as the dynamic change bug. In the iTask WFMS, workflows are specified using a radically different approach: workflows are constructed in a compositional style, using pure functions and combinators as self-contained building blocks. This paper introduces a change concept for the iTask system where self-contained tasks can be replaced by other self-contained tasks, thereby preventing dynamic change bugs. The static and dynamic typing system furthermore guarantees that these tasks have compatible types.

• Joao Paulo Fernandes, Joao Saraiva, Daniel Seidel and Janis Voigtlander. Strictification of Circular Programs
  
  Abstract: Circular functional programs (necessarily evaluated lazily) have been used as algorithmic tools, as attribute grammar implementations,and as target for program transformation techniques. Classically,Richard Bird [1984] showed how to transform certain multi-traversal programs (which could be evaluated strictly or lazily) into one-traversal ones using circular bindings. Can we go the other way, even for programs that are not in the image of his technique?That is the question we pursue in this paper. We develop a methodology that on the one hand lets us deal with typical examples corresponding to attribute grammars, but on the other hand also helps to derive new algorithms for problems not previously in reach.

• Carl Friedrich Bolz, Antonio Cuni, Maciej Fijalkowski, Michael Leuschel, Samuele Pedroni and Armin Rigo. Allocation Removal by Partial Evaluation in a Tracing JIT
  
  Abstract: The performance of many dynamic language implementations suffers from high allocation rates and runtime type checks. This makes dynamic languages less applicable to purely algorithmic problems, despite their growing popularity. In this paper we present a simple compiler optimization based on online partial evaluation to remove object allocations and runtime type checks in the context of a tracing JIT. We evaluate the optimization using a Python VM and find that it gives good results for all our (real-life) benchmarks.

• Rafael Caballero. A Program Transformation for Returning States in Functional-Logic Programs
  
  Abstract: This paper studies the conditions necessary to safely introduce new values as part of the results of function rules in functional-logic programs. The idea is to consider an initial functional-logic program and to produce, by means of a program transformation, a new program including states. Each rule of the new program returns pairs of values, with the first value the same as in the original program, and the second one a new value that can be defined in terms of the values returned by the function calls occurring in the rule. We prove that the transformation ensures the equivalence of the two programs with respect to the constructor-based ReWriting^? Logic, a suitable semantics for functional-logic programs.

• Dimitrios Vardoulakis and Olin Shivers. Ordering Multiple Continuations on the Stack
  
  Abstract: Passing multiple continuation arguments to a function in CPS form allows one to encode a wide variety of direct-style control constructs, such as conditionals, exceptions, and multi-return function calls. We show that, with a simple syntactic restriction on the CPS language, one can prove that these multi-continuation arguments can be compiled into stack frames in the traditional manner. The restriction comes with no loss in expressive power, since we can still encode the same control mechanisms.In addition, we show that tail calls can be generalized efficiently for many continuations because the run-time check to determine which continuation to pop to can be avoided with a simple static analysis. A prototype implementation shows that our analysis is very precise, with small additional cost in compilation time.

• Olaf Chitil. A Semantics for Lazy Assertions
  
  Abstract: Lazy functional programming languages need lazy assertions to ensure that assertions preserve the meaning of programs. Examples in this paper demonstrate that previously proposed lazy assertions nonetheless break basic semantic equivalences, because they include a non-deterministic disjunction combinator. The objective of this paper is to determine "correct" definitions for lazy assertions. The starting point is our formalisation of basic properties such as laziness, taking them as axioms of our design space. We develop the first denotational semantics for lazy assertions where assertions denote subdomains. We define a weak disjunction combinator and together with a conjunction combinator assertions form a bounded distributive lattice. From the established laws we derive an efficient prototype implementation of lazy assertions for Haskell as a library.

• Peter A. Jonsson and Johan Nordlander. Taming Code Explosion in Supercompilation
  
  Abstract: Supercompilation algorithms can perform great optimizations but sometimes suffer from the problem of code explosion. This results in huge binaries which might hurt the performance on a modern processor. We present a supercompilation algorithm that is fast enough to speculatively supercompile expressions and discard the result if it turned out bad. This allows us to supercompile large parts of the imaginary and spectral parts of nofib in a matter of seconds while keeping the binary size increase below 5%.

• Jacques Carette, Mustafa Elsheikh and Spencer Smith. A Generative Geometric Kernel
  
  Abstract: We present the design and implementation of a generative geometric kernel. The kernel generator is generic, type-safe, parametrized by many design-level choices and extensible. The resulting code has minimal traces of the design abstractions. We achieve genericity through a layered design deriving concepts from affine geometry, linear algebra and abstract algebra. We achieve parametrization and type-safety by using OCaml's module system, including higher order modules. The cost of abstraction is removed by using MetaOCaml^?'s support for code generation coupled with some annotations atop the code type.

• Yan Wang and Veronica Gaspes. An Embedded Language for Programming Protocol Stacks in Embedded Systems
  
  Abstract: Protocol stack specifications are well-structured documents that follow a number of conventions and notations that have proven very useful for the design and dissemination of communication protocols.Protocol stack implementations on the other hand, are done in low-level languages, using error-prone programming techniques resulting in programs that are difficult to relate to the specifications,difficult to maintain, modify, extend and reuse. To overcome these problems we propose a domain-specific language that provides abstractions close to the notations used in protocol specifications.From descriptions in our language we generate C programs that can be integrated with other systems software. The language provides constructs to describe packet formats, including physical layout, constraints and dependencies. It also provides constructs for state machines and for layering protocols into stacks. Experiments show that the C programs we generate are comparable in performance and binary size to hand-crafted C programs.

Tool demonstration papers:

• Elvira Albert, Richard Bubel, Samir Genaim, Reiner Hahnle, German Puebla and Guillermo Roman Diez. Verified Resource Guarantees using COSTA and KeY
  
  Abstract: Resource guarantees allow being certain that programs will run within the indicated amount of resources, which may refer to memory consumption, number of instructions executed, etc. This information can be very useful, especially in real-time and safety-critical applications. Nowadays, a number of automatic tools exist, often based on type systems or static analysis, which produce such resource guarantees. In spite of being based on theoretically sound techniques, the implemented tools may contain bugs which render the resource guarantees thus obtained not completely trustworthy. Performing full-blown verification of such tools is a daunting task, since they are large and complex. In this work we investigate an alternative approach whereby, instead of the tools, we formally verify the results of the tools. We have implemented this idea using COSTA, a state-of-the-art static analysis system, for producing resource guarantees and KeY^?, a state-of-the-art verification tool, for formally verifying the correctness of such resource guarantees. Our preliminary results show that the proposed tool cooperation can be used for automatically producing verified resource guarantees.

Important Dates

• Paper submission: Fri, October 22, 2010, 23:59, Apia time (1 week extension)
• Author notification: Mon, November 15, 2010
• Camera-ready papers: Mon, November 22, 2010, submit to http://www.sheridanprinting.com/typedept/pepm.htm

• Workshop: Mon-Tue, January 24-25, 2011

Invited Speakers

We are proud to present the following three invited talks:

• Charles Consel (INRIA/LaBRI/University of Bordeaux, France): DiaSuite: A Paradigm-Oriented Software Development Approach
  
  

• Olivier Danvy (Aarhus University, Denmark): A Walk in the Semantic Park
  
  

• Martin Rinard (MIT, USA): Probabilistic Accuracy Bounds for Perforated Programs
  
  

Program Committee

Program Chairs

• Siau-Cheng Khoo (National University of Singapore, Singapore)
• Jeremy G. Siek (University of Colorado at Boulder, USA)

Program Committee Members

• Jacques Carette (McMaster University, Canada)
• Kung Chen (National Chengchi University, Taiwan)
• Evelyne Contejean (CNRS, France)
• Francisco Javier Lopez Fraguas (University of Madrid, Spain)
• Ronald Garcia (Carnegie Mellon University, USA)
• Jurriaan Hage (Utrecht University, The Netherlands)
• Zhenjiang Hu (National Institute of Informatics, Japan)
• Shan Shan Huang (LogicBlox^? Inc., USA)
• Yukiyoshi Kameyama (University of Tsukuba, Japan)
• Ralf Lammel (University of Koblenz-Landau, Germany)
• Michael Leuschel (University of Düsseldorf, Germany)
• Andrew Moss (University of Bristol, UK)
• Maurizio Proietti (CNR, Italy)
• Peter Sestoft (IT University of Copenhagen, Denmark)
• Chung-chieh Shan (Rutgers, USA)
• Scott Stoller (Stony Brook University, USA)
• Peter Thiemann (Universitat Freiburg, Germany)
• Simon Thompson (Kent University, UK)
• German Vidal (Universidad Politecnica de Valencia, Spain)
• Edwin Westbrook (Rice University, USA)

----------------------------------------------------------------------
                            Call For Papers 

                     ACM SIGPLAN 2010 Workshop on 
         PARTIAL EVALUATION AND PROGRAM MANIPULATION (PEPM'10)

                             Madrid, Spain
                          January, 2010 
                     (Co-located with POPL 2010)

             http://www.program-transformation.org/PEPM10
----------------------------------------------------------------------

The PEPM Symposium/Workshop series aims to bring together researchers
and practitioners working in the areas of program manipulation,
partial evaluation, and program generation. PEPM focuses on
techniques, theory, tools, and applications of analysis and
manipulation of programs.

The 2010 PEPM workshop will be based on a broad interpretation of
semantics-based program manipulation and continue previous years'
successful effort to expand the scope of PEPM significantly beyond the
traditionally covered areas of partial evaluation and specialization
and include practical applications of program transformations such as
refactoring tools, and practical implementation techniques such as
rule-based transformation systems. In addition, the scope of PEPM
covers manipulation and transformations of program and system
representations such as structural and semantic models that occur in
the context of model-driven development. In order to reach out to
practitioners, a separate category of tool demonstration papers will
be solicited.

----------------------------------------------------------------------

Topics of interest for PEPM'10 include, but are not limited to:

 + Program and model manipulation techniques such as transformations
   driven by rules, patterns, or analyses, partial evaluation,
   specialization, program inversion, program composition, slicing, 
   symbolic execution, refactoring, aspect weaving, decompilation, 
   and obfuscation. 

 + Program analysis techniques that are used to drive program/model
   manipulation such as abstract interpretation, static analysis,
   binding-time analysis, dynamic analysis, constraint solving, and
   type systems.

 + Analysis and transformation for programs/models with advanced
   features such as objects, generics, ownership types, aspects,
   reflection, XML type systems, component frameworks, and middleware.

 + Techniques that treat programs/models as data objects including
   meta-programming, generative programming, staged computation, and
   model-driven program generation and transformation.

 + Application of the above techniques including experimental studies,
   engineering needed for scalability, and benchmarking. Examples of
   application domains include legacy program understanding and
   transformation, domain-specific language implementations,
   scientific computing, middleware frameworks and infrastructure
   needed for distributed and web-based applications, resource-limited
   computation, and security.

We especially encourage papers that break new ground including
descriptions of how program/model manipulation tools can be integrated
into realistic software development processes, descriptions of robust
tools capable of effectively handling realistic applications, and new
areas of application such as rapidly evolving systems, distributed and
webbased programming including middleware manipulation, model-driven
development, and on-the-fly program adaptation driven by run-time or
statistical analysis.

----------------------------------------------------------------------

Submission Categories and Guidelines

Regular research papers must not exceed 10 pages in ACM Proceedings
style. Tool demonstration papers must not exceed 4 pages in ACM
Proceedings style, and authors will be expected to present a live
demonstration of the described tool at the workshop. Suggested topics,
evaluation criteria, and writing guidelines for both research tool
demonstration papers will be made available on the PEPM'10 web
site. Papers should be submitted electronically via the workshop web
site. The workshop proceedings will be published in the ACM Digital
Library and selected papers may be invited for a journal special
issue dedicated to PEPM'10.

----------------------------------------------------------------------

Important Dates 

 + to be announced
 + Abstracts due:  
 + Submission:    
 + Notification:   
 + Camera-ready:   
 + Workshop:      January, 2010 

-----------------------------------------------------------------------

Program Chairs

    * John Gallagher (Roskilde University, Denmark)
    * Janis Voigtlaender (Technische Universitaet Dresden, Germany)

Program Committee Members

    * to be announced

-----------------------------------------------------------------------

POPL 2010

-- JanisVoigtlaender - 18 Jun 2009

• GPCE06-FirstCallForPapers.pdf: Flyer with first call for papers for GPCE'06

20th Anniversary Edition

Mon-Tue, January 24-25, 2011
Austin, Texas, USA
co-located with POPL'11

Sponsored by ACM SIGPLAN

http://www.program-transformation.org/PEPM11

Submissions

10 pages in SIGPLAN proceedings style (sigplanconf.cls) reporting research results and/or experience related to the topics above (PC co-chairs can advise on appropriateness). We particularly encourage original high-quality reports on applying GPCE technologies to real-world problems, relating ideas and concepts from several topics, or bridging the gap between theory and practice.

Papers

Acceptance Rate

Participants

• Paper submission: Fri, October 22, 2010, 23:59, Apia time (1 week extension)
• Author notification: Mon, November 15, 2010
• Camera-ready papers: Mon, November 22, 2010, submit to http://www.sheridanprinting.com/typedept/pepm.htm

• Workshop: Mon-Tue, January 24-25, 2011

• Charles Consel (INRIA/LaBRI/University of Bordeaux, France): DiaSuite: A Paradigm-Oriented Software Development Approach
  
  

• Olivier Danvy (Aarhus University, Denmark): A Walk in the Semantic Park
  
  

• Martin Rinard (MIT, USA): Probabilistic Accuracy Bounds for Perforated Programs
  
  

Important Dates

• Paper submission: Fri, October 22, 2010, 23:59, Apia time (1 week extension)
• Author notification: Mon, November 15, 2010
• Camera-ready papers: Mon, November 22, 2010, submit to http://www.sheridanprinting.com/typedept/pepm.htm

• Workshop: Mon-Tue, January 24-25, 2011

Electronic Submission

Papers must be submitted electronically in PDF format at

• http://www.easychair.org/conferences/?conf=pepm11

PEPM 2011 is the 20th edition of the PEPM series! To celebrate this 20th anniversary, the general chairs from the first PEPM, Charles Consel and Olivier Danvy, will give invited talks on the first day of the conference and Martin Rinard will give the invited talk on the second day of the conference.

The PEPM Symposium/Workshop series aims to bring together researchers and practitioners working in the areas of program manipulation, partial evaluation, and program generation. PEPM focuses on techniques, theories, tools, and applications of analysis and manipulation of programs.

The 2011 PEPM workshop will be based on a broad interpretation of semantics-based program manipulation in a continued effort to expand the scope of PEPM significantly beyond the traditionally covered areas of partial evaluation and specialization and include practical applications of program transformations such as refactoring tools, and practical implementation techniques such as rule-based transformation systems. In addition, it covers manipulation and transformations of program and system representations such as structural and semantic models that occur in the context of model-driven development. In order to reach out to practitioners, there is a separate category of tool demonstration papers.

Topics of interest for PEPM'11 include, but are not limited to:

• Program and model manipulation techniques such as transformations driven by rules, patterns, or analyses, partial evaluation, specialization, program inversion, program composition, slicing, symbolic execution, refactoring, aspect weaving, decompilation, and obfuscation.

• Program analysis techniques that are used to drive program/model manipulation such as abstract interpretation, static analysis, binding-time analysis, dynamic analysis, constraint solving, type systems, automated testing and test case generation.

• Analysis and transformation for programs/models with advanced features such as objects, generics, ownership types, aspects, reflection, XML type systems, component frameworks, and middleware.

• Techniques that treat programs/models as data objects including meta-programming, generative programming, deep embedded domain-specific languages, program synthesis by sketching and inductive programming, staged computation, and model-driven program generation and transformation.

• Application of the above techniques including experimental studies, engineering needed for scalability, and benchmarking. Examples of application domains include legacy program understanding and transformation, DSL implementations, visual languages and end-user programming, scientific computing, middleware frameworks and infrastructure needed for distributed and web-based applications, resource-limited computation, and security.

We especially encourage papers that break new ground including descriptions of how program/model manipulation tools can be integrated into realistic software development processes, descriptions of robust tools capable of effectively handling realistic applications, and new areas of application such as rapidly evolving systems, distributed and web-based programming including middleware manipulation, model-driven development, and on-the-fly program adaptation driven by run-time or statistical analysis.

Student attendants with accepted papers can apply for a SIGPLAN PAC grant to help cover travel expenses. PAC also offers other support, such as for child-care expenses during the meeting or for travel costs for companions of SIGPLAN members with physical disabilities, as well as for travel from locations outside of North America and Europe. For details on the PAC program, see the PAC web page.

There will be formal proceedings published by ACM Press. In addition to printed proceedings, accepted papers will be included in the ACM Digital Library. Selected papers may later on be invited for a journal special issue dedicated to PEPM'11.

Follow this link for the complete Call for Papers.

History
Previous Meetings
Statistics

• MyName^? - myname@site.edu

Note: It is helpful to insert your name in alphabetical order (by first name -- ignore the "Main.") -- then you can find your name (or not) more easily if you wish to remove it or confirm that you are on the list.

Related topics: TWikiUsers, TWikiRegistration

TWiki.PEPM11 Web Preferences

The following settings are web preferences of the TWiki.PEPM11 web. These preferences overwrite the site-level preferences in TWikiPreferences, and can be overwritten by user preferences (your personal topic, i.e. TWikiGuest in the TWiki.Main web)

GPCE variables:

• Set URLPEPM11 = http://www.program-transformation.org/PEPM11
• Set URLFLYER = ?
• Set URLFLYERALT = ?
• Set URLPOPL11 = http://www.cse.psu.edu/popl/11/
• Set URLLOCAL = ?
• Set URLNICE = ?

• Set PAPERPRESUBMISSION = Sun, October 10, 2010
• Set PAPERSUBMISSION = Fri, October 22, 2010, 23:59, Apia time (1 week extension)
• Set PAPERNOTIFICATION = Mon, November 15, 2010
• Set PAPERCAMERAREADY = Mon, November 22, 2010

• Set EARLYREGISTRATION = ??, 2010
• Set LATEREGISTRATION = ??, 2010

• Set CONFERENCEDAYS = Mon-Tue, January 24-25, 2011

• Set VENUE = Austin, Texas, USA

Preferences:

• Set WEBTITLE = ACM SIGPLAN 2011 Workshop on Partial Evaluation and Program Manipulation
• Set SHORTWEBTITLE = PEPM2011

• List of topics of the TWiki.PEPM11 web:
  • Set WEBTOPICLIST = Home | Changes | Index | Search | Go

• Web specific background color: (Pick a lighter one of the StandardColors)
  • Set WEBBGCOLOR = #D0D0D0

• Exclude web from a web="all" search: (Set to on for hidden webs)
  • Set NOSEARCHALL =

• Default template for new topics and form(s) for this web:
  • WebTopicEditTemplate^?: Default template for new topics in this web. (Site-level is used if topic does not exist)
  • TWiki.WebTopicEditTemplate: Site-level default template
  • TWikiForms: How to enable form(s)
  • Set WEBFORMS =

• Users or groups who are not / are allowed to view / change / rename topics in the PEPM11 web: (See TWikiAccessControl)
  • Set DENYWEBVIEW =
  • Set ALLOWWEBVIEW =
  • Set DENYWEBCHANGE =
  • Set ALLOWWEBCHANGE = PepmGroup
  • Set DENYWEBRENAME =
  • Set ALLOWWEBRENAME = PepmGroup

• Users or groups allowed to change or rename this WebPreferences topic: (I.e. TWikiAdminGroup)
  • Set ALLOWTOPICCHANGE = TWikiAdminGroup PepmGroup
  • Set ALLOWTOPICRENAME = TWikiAdminGroup PepmGroup

• Web preferences that are not allowed to be overridden by user preferences:
  • Set FINALPREFERENCES = WEBTOPICLIST, DENYWEBVIEW, ALLOWWEBVIEW, DENYWEBCHANGE, ALLOWWEBCHANGE, DENYWEBRENAME, ALLOWWEBRENAME

Notes:

• A preference is defined as:
  6 spaces * Set NAME = value
  Example:
  • Set WEBBGCOLOR = #FFFFC0
• Preferences are used as TWikiVariables by enclosing the name in percent signs. Example:
  • When you write variable %WEBBGCOLOR% , it gets expanded to #D0D0D0 .
• The sequential order of the preference settings is significant. Define preferences that use other preferences first, i.e. set WEBCOPYRIGHT before WIKIWEBMASTER since %WEBCOPYRIGHT% uses the %WIKIWEBMASTER% variable.
• You can introduce new preferences variables and use them in your topics and templates. There is no need to change the TWiki engine (Perl scripts).

Related Topics:

• TWikiPreferences has site-level preferences.
• TWikiUsers has a list of user topics. User topics can have optional user preferences.
• TWikiVariables has a list of common %VARIABLES%.
• TWikiAccessControl explains how to restrict access by users or groups.

• Topic index: List of PEPM11 topics in alphabetical order.
  |All|A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z|
  | All topics in BookView |

• Jump to topic: If you already know the name of the topic, enter the name of the topic into the GoBox at the top

• WebChanges: Find out what topics in PEPM11 have changed recently

• How to edit text:
  • Make changes to topics in GoodStyle,
  • Learn the TextFormattingRules, and
  • Have a look at the TextFormattingFAQ

HistoricalStatistics for TWiki.PEPM11 Web

Notes:

• Do not edit this topic, it is updated automatically. (You can also force an update)
• TWikiDocumentation tells you how to enable the automatic updates of the statistics.
• Suggestion: You could archive this topic once a year and delete the previous year's statistics from the table.

• RoadMap^?
• WebIndex: all topics in the PEPM11 web
• WebSearch: find topics

Tracking activity

• WebNews: selected changes
• WebChanges: recent changes
• WebNotify: email notification of changes
• WebStatistics: usage counts

Look and feel

• WebPreferences: values of variables
• WebContents^?: web specific entries in the side bar